package com.lan.extend.dict.utils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.RegexPatternTypeFilter;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

public class ClassUtil {

    private static final Logger log = LogManager.getLogger(ClassUtil.class);

    /**
     * 扫描包路径下的所有类
     *
     * @param packageName 包路径
     * @return 包下所有类的路径
     */
    public static List<String> getClasses(String packageName) {
        List<String> classNames = new ArrayList<>();
        ClassPathScanningCandidateComponentProvider scanner =
                new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new RegexPatternTypeFilter(Pattern.compile(".*")));

        Set<BeanDefinition> beans = scanner.findCandidateComponents(packageName);
        for (BeanDefinition bean : beans) {
            classNames.add(bean.getBeanClassName());
        }
        return classNames;
    }

    /**
     * 获取方法的返回值
     *
     * @param method 方法
     * @return
     */
    public static String getReturnType(Method method) {
        // 获取方法的返回类型（原始类型）
        Type returnType = method.getGenericReturnType();

        // 检查返回类型是否是ParameterizedType（即是否带有泛型参数）
        if (returnType instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) returnType;

            // 获取泛型参数数组
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

            // 这里我们假设只有一个泛型参数（即List<User>中的User）
            if (actualTypeArguments.length == 1) {
                Type genericType = actualTypeArguments[0];

                // 输出泛型参数的类型名称
                if (genericType instanceof Class<?>) {
                    Class<?> genericClass = (Class<?>) genericType;
                    return genericClass.getName();
                } else {
                    // 处理非Class类型的泛型参数（比如其他类型的泛型，如TypeVariable等）
                    return genericType.getTypeName();
                }
            }
        } else {
            // 处理非ParameterizedType的返回类型
            return returnType.getTypeName();
        }
        return null;
    }
}
